home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_11_12 / dean / demo.c < prev    next >
C/C++ Source or Header  |  1993-11-20  |  9KB  |  417 lines
  1. /* Listing 1 */
  2.  
  3. /****************************************************/
  4. /*                                                  */
  5. /* Demonstration program to transfrom images for    */
  6. /* 320 x 200 256 color mode, Borland C              */
  7. /* Christopher Dean 05/10/93                        */
  8. /*                                                  */
  9. /****************************************************/
  10.  
  11.  
  12.  
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <graphics.h>
  16. #include <string.h>
  17. #include <stdlib.h>
  18. #include <dos.h>
  19. #include <conio.h>
  20. #include <alloc.h>
  21. #include <process.h>
  22. #include <bios.h>
  23. #include <math.h>
  24.  
  25. /* key defines */
  26.  
  27. #define  KEY_END     0x4f00
  28. #define  KEY_DOWN    0x5000
  29. #define  KEY_LEFT    0x4b00
  30. #define  KEY_RIGHT   0x4d00
  31. #define  KEY_UP      0x4800
  32.  
  33. /* direction defines */
  34.  
  35. #define SHEAR_VERT_RIGHT 0
  36. #define SHEAR_VERT_LEFT 1
  37. #define SHEAR_HORZ_RIGHT 1
  38. #define SHEAR_HORZ_LEFT 0
  39.  
  40. /* function prototypes for transformation routines */
  41.  
  42. extern char *TransXY(char *buffer,int width,
  43.     int height,int newwidth,int newheight);
  44. extern char *ShearVert(char *buffer,int width,
  45.     int height,int newwidth,int newheight);
  46. extern char *ShearHorz(char *buffer,int width,
  47.     int height,int newwidth,int newheight);
  48.  
  49. /* detect the VGA256.BGI driver */
  50.  
  51. static int huge DetectVGA256(void)
  52. {
  53.   int DetectedDriver;
  54.   int SuggestedMode;
  55.  
  56.   detectgraph(&DetectedDriver,&SuggestedMode);
  57.   if ((DetectedDriver == VGA) ||
  58.     (DetectedDriver == MCGA))
  59.      return(0);
  60.   else
  61.      return (grError);
  62. }
  63.  
  64. /* initialize the 320 x 200 256 color mode */
  65.  
  66. void InitGraphics (void)
  67. {
  68.    int GraphMode;
  69.    int GraphDriver = DETECT;
  70.  
  71.   detectgraph(&GraphDriver,&GraphMode);
  72.   if ((GraphDriver == MCGA) ||
  73.      (GraphDriver == VGA)) {
  74.      GraphDriver = MCGA;
  75.      GraphMode = MCGAC0;
  76.      installuserdriver("VGA256",DetectVGA256);
  77.      GraphDriver = DETECT;
  78.      initgraph(&GraphDriver,&GraphMode,"");
  79.   }
  80.  
  81. }
  82.  
  83. /* my own version of Borland'c putimage function.  If
  84.    the color in the buffer is 255 then it does not
  85.    put anything, the background color remains. */
  86.  
  87. void xputimage(int left,int top,void far *bitmap)
  88. {
  89.    int y,i;
  90.    int width,height;         /* dimensions of image */
  91.    char *w;                  /* pointer to screen */
  92.    char *bitmap1;
  93.    unsigned char c;
  94.  
  95.  
  96.    /* get image dimensions from buffer and set bitmap1
  97.       to start of image */
  98.  
  99.    width = *((int *)bitmap);
  100.    height = *((int *)bitmap+1);
  101.    bitmap1 = (char *) bitmap+4;
  102.  
  103.  
  104.    /* set screen pointer */
  105.  
  106.    w = (char far *) 0xA0000000L + ((long)top * 320L) +
  107.        (long)left;
  108.  
  109.    /* loop through rows of the image, placing them on
  110.       the screen */
  111.  
  112.    for (y=top;y<top+height;y++) {
  113.       for (i = 0; i < width; ++i) {
  114.      c = *((char *) bitmap1);
  115.      ++bitmap1;
  116.      if (c != 0xff) /* preserve the background? */
  117.         *(w+(long) i) = c;
  118.  
  119.      /* just for the demo set the background to
  120.         black. Leave this out if you want to
  121.         preserve the background. */
  122.  
  123.      else *(w+(long) i) = 0;
  124.       }
  125.  
  126.       w += 320L;   /* next row on screen */
  127.    }
  128.  
  129. }
  130.  
  131.  
  132. main()
  133. {
  134.    int i,j;
  135.    char *newpic,*newpic1,*newpic2=NULL;
  136.    int w,h,nw,nh,nw1,nh1; /* image dimensions */
  137.    char text[40];
  138.    int key,valid_key,option;
  139.  
  140.  
  141.    do {
  142.       printf("\n\nDemonstration functions:\n\n");
  143.       printf("%s\n%s\n%s\n%s\n%s\n%s\n%s\n\n",
  144.      "  1) Scaling",
  145.      "  2) Vertical Shearing Right",
  146.      "  3) Vertical Shearing Left",
  147.      "  4) Horizontal Shearing Right",
  148.      "  5) Horzontal Shearing Left",
  149.      "  6) Rotations",
  150.      "  7) Exit");
  151.       key = getch();
  152.       valid_key = 1;
  153.       switch(key) {
  154.      case '1':
  155.         option = 0;
  156.         break;
  157.      case '2':
  158.         option = 1;
  159.         break;
  160.      case '3':
  161.         option = 2;
  162.         break;
  163.      case '4':
  164.         option = 3;
  165.         break;
  166.      case '5':
  167.         option = 4;
  168.         break;
  169.      case '6':
  170.         option = 5;
  171.         break;
  172.      case '7':
  173.         option = 6;
  174.         break;
  175.      default:
  176.         valid_key = 0;
  177.       }
  178.    }
  179.    while (!valid_key);
  180.    if (option == 6)
  181.      exit(0);
  182.  
  183.  
  184.    InitGraphics(); /* Initialize graphics */
  185.  
  186.  
  187.    /* draw the house */
  188.  
  189.    setfillstyle(SOLID_FILL,0);
  190.    bar(0,0,319,199);
  191.    setcolor(15);
  192.    setlinestyle(SOLID_LINE,0,THICK_WIDTH);
  193.    rectangle(91,71,171,121);
  194.    line(1,21,91,71);
  195.    line(1,71,91,121);
  196.    line(1,21,1,71);
  197.    line(1,21,41,1);
  198.    line(41,1,131,51);
  199.    line(131,51,171,71);
  200.    line(91,71,131,51);
  201.    setcolor(2);
  202.    rectangle(121,96,141,121);
  203.    newpic = malloc(imagesize(0,0,182,134));
  204.    getimage(0,0,182,134,newpic);
  205.  
  206.    /* initialize dimensions */
  207.  
  208.    nw = nw1 = w = *((int *) newpic);
  209.    nh = nh1 = h = *((int *) newpic+1);
  210.  
  211.    setcolor(15);
  212.    sprintf(text,"width: %d height: %d",nw,nh);
  213.    outtextxy(10,190,text);
  214.    while ((key = bioskey(0)) != KEY_END) {
  215.       switch(option) {
  216.     case 0:
  217.  
  218.        /* scaling */
  219.  
  220.        switch(key) {
  221.           case KEY_LEFT:
  222.  
  223.          /* decrease width */
  224.  
  225.          bar(nw,1,nw-5,1+nh);
  226.          nw -= 5;
  227.          if (nw < 1)  /* keep within screen */
  228.             nw = 1;
  229.          break;
  230.            case KEY_RIGHT:
  231.  
  232.          /* increase width */
  233.  
  234.          nw = nw + 5;
  235.          if (nw > 318) /* keep within screen */
  236.            nw = 318;
  237.          break;
  238.            case KEY_UP:
  239.  
  240.          /* decrease height */
  241.  
  242.          bar(1,nh,1+nw,nh-5);
  243.          nh -= 5;
  244.          if (nh < 1)
  245.             nh = 1;
  246.          break;
  247.            case KEY_DOWN:
  248.  
  249.          /* increase height */
  250.  
  251.          nh = nh + 5;
  252.          if (nh > 189)
  253.            nh = 189;
  254.          break;
  255.  
  256.        }
  257.  
  258.        /* change size */
  259.  
  260.        newpic1 = TransXY(newpic,w,h,nw,nh);
  261.        break;
  262.     case 1:
  263.     case 2:
  264.  
  265.        /* vertical shearing */
  266.  
  267.        switch(key) {
  268.           case KEY_DOWN:
  269.  
  270.          /* increase height of shear */
  271.  
  272.          nh += 5;
  273.          if (nh > 189)
  274.            nh = 189;
  275.          break;
  276.           case KEY_UP:
  277.  
  278.          /* decrease height of shear */
  279.  
  280.          bar(1,1+nh,1+w,nh-4);
  281.          nh -= 5;
  282.          if (nh < h)
  283.             nh = h;
  284.          break;
  285.        }
  286.        if (option == 1)
  287.           newpic1 = ShearVert(newpic,w,h,nh,
  288.          SHEAR_VERT_RIGHT);
  289.        else
  290.           newpic1 = ShearVert(newpic,w,h,nh,
  291.           SHEAR_VERT_LEFT);
  292.        break;
  293.     case 3:
  294.     case 4:
  295.  
  296.        /* horizontal shearing */
  297.  
  298.        switch(key) {
  299.          case KEY_RIGHT:
  300.  
  301.            /* increase width of shear */
  302.  
  303.            nw += 5;
  304.            if (nw > 318)
  305.          nw = 318;
  306.            break;
  307.          case KEY_LEFT:
  308.  
  309.            /* decrease width of shear */
  310.  
  311.            bar(1+nw,1,nw-4,1+h);
  312.            nw -= 5;
  313.            if (nw < w)
  314.          nw = w;
  315.            break;
  316.        }
  317.        if (option == 4)
  318.           newpic1 = ShearHorz(newpic,w,h,nw,
  319.          SHEAR_HORZ_LEFT);
  320.        else
  321.           newpic1 = ShearHorz(newpic,w,h,nw,
  322.          SHEAR_HORZ_RIGHT);
  323.        break;
  324.     case 5:
  325.  
  326.        /* rotations */
  327.  
  328.        switch(key) {
  329.  
  330.          /* rotate clockwise */
  331.  
  332.          case KEY_RIGHT:
  333.         if (nw <= 273)
  334.           nw += 5;
  335.         else nh -= 5;
  336.  
  337.         if (nw < w) {
  338.  
  339.         /* handle case when we have previously
  340.            been rotating counter-clockwise */
  341.  
  342.  
  343.            /* make sure we always shear >
  344.               width of image */
  345.  
  346.            nw1 = w + w - nw;
  347.            newpic2 = ShearHorz(newpic,w,h,nw1,
  348.                SHEAR_HORZ_RIGHT);
  349.            nh += 5;
  350.  
  351.            /* make sure we always shear >
  352.               height of image */
  353.  
  354.            nh1 = h + h - nh;
  355.            newpic1 = ShearVert(newpic2,nw1,h,
  356.               nh1,SHEAR_VERT_LEFT);
  357.         }
  358.         else {
  359.            newpic2 = ShearHorz(newpic,w,h,nw,
  360.               SHEAR_HORZ_LEFT);
  361.            nh += 5;
  362.            newpic1 = ShearVert(newpic2,nw,h,
  363.               nh,SHEAR_VERT_RIGHT);
  364.         }
  365.         break;
  366.          case KEY_LEFT:
  367.  
  368.          /* rotate counter-clockwise */
  369.  
  370.         if (nw1 <= 273)
  371.            nw -= 5;
  372.         else nh += 5;
  373.         if (nw < w) {
  374.            nw1 = w + w - nw;
  375.            newpic2 = ShearHorz(newpic,w,h,nw1,
  376.                SHEAR_HORZ_RIGHT);
  377.            nh -= 5;
  378.            nh1 = h + h - nh;
  379.            newpic1 = ShearVert(newpic2,nw1,h,
  380.                nh1,SHEAR_VERT_LEFT);
  381.         }
  382.         else {
  383.  
  384.           /* handle case when we have
  385.              previously been rotating
  386.              clockwise */
  387.  
  388.           newpic2 = ShearHorz(newpic,w,h,nw,
  389.               SHEAR_HORZ_LEFT);
  390.           nh -= 5;
  391.           newpic1 = ShearVert(newpic2,nw,h,nh,
  392.               SHEAR_VERT_RIGHT);
  393.         }
  394.         break;
  395.        }
  396.       }
  397.       xputimage(0,0,newpic1);
  398.       setcolor(15);
  399.       if ((option == 5) && (nw < w))
  400.  
  401.      /* use different dimensio